import java.util.Arrays;

public class Main {
    public static void main(String[] args) {


        //int[] arr = {1,2,3,4,5,6};
        //String newArr= Arrays.toString(arr);
        //数组转化为字符串
        //System.out.println(newArr);
        //System.out.println("Hello world!");

        //java 中提供了java.util.Arrays包，里面包含了数组操作常用的方法
        //func();


        //System.out.println(find(arr,6));
        //System.out.println(avg(arr));
        //System.out.println(binarySeacch(arr,6));
        //
        //System.out.println("排序前arr："+Arrays.toString(arr));
        //bubbleSort(arr);
        //Arrays.sort(arr);//内置的是升序排序
        //System.out.println("排序后arr："+Arrays.toString(arr));

        //数组逆序
        //int []arr={1,2,3,4,5,6,7,8,9};
        //System.out.println("逆序前："+Arrays.toString(arr));
        //reverse(arr);
        //System.out.println("逆序后："+Arrays.toString(arr));

        //二维数组：本质上也是一维数组，只是一维数组的每个元素都是一个一维数组
//        int[][] arr = {
//                {1, 2, 3, 4},
//                {5, 6, 7, 8},
//                {9, 10, 11, 12}
//        };
//        //print(arr);
//        int [][][]arr2=new int[3][4][5];
//        init(arr2);
        //System.out.println();


    }
    public static void init(int[][][]arr2){
        for (int x = 0; x <arr2.length ; x++) {
            for (int y = 0; y <arr2[x].length ;y++) {
                for (int z = 0; z < arr2[x][y].length; z++) {
                    arr2[x][y][z]=9;
                    System.out.printf("%d\t",arr2[x][y][z]);
                }
                System.out.println();
            }
            System.out.println();
        }
        //System.out.println();
    }
    public static void print(int[][]arr){
        for (int row = 0; row <arr.length ; row++) {
            for (int col = 0; col <arr[row].length ; col++) {
                System.out.printf("%d\t",arr[row][col]);
            }
            System.out.println();
        }
    }



    public static void reverse(int[]arr) {
        int left = 0;
        int right = arr.length - 1;
//        while(left<right){
//            int tmp=arr[left];
//            arr[left]=arr[right];
//            arr[right]=tmp;
//            left++;
//            right--;
//        }
        for (; left < right; left++, right--) {//从此处发现，fori形式的循环，先去初始化变量，然后判断条件是否成立
            //然后去执行循环语句，最后才去加加减减
            //
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }

    //从大到小的排序
    public static void bubbleSort(int[]arr){
        for (int i = 0; i < arr.length; i++) {
//            for (int j = 0; j < arr.length-1-i; j++) {
//                if(arr[j]<arr[j+1]){//j+1会不会越界呢,这个不会越出去，可能会和一个已经排好队的去比较，但是肯定交换不了
//                    //
//                    int tmp=arr[j];
//                    arr[j]=arr[j+1];
//                    arr[j+1]=tmp;
//                }
//            }
            //
            for (int j = 1; j < arr.length-i; j++) {//每一趟都会拍好一个，i躺，就会排好i个，所以减去已经排好的
                if(arr[j-1]<arr[j]){//j+1会不会越界呢？
                    int tmp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=tmp;
                }
            }
        }
    }
    public static void swap(int x,int y){

        return ;
    }

    //查找数组中的指定元素（二分法）
    //针对有序数组，可以更加高效的使用二分
    //不断的去找中间值，判断中间值和搜索值的大小关系
    //一次减少一半的区间
    //
    public static int binarySeacch(int[]arr,int toFind){
        int left=0;
        int right=arr.length-1;

        while(left<=right){
            int mid=(left+right)/2;
            if(arr[mid]>toFind){//代表要找的在中间左边
                right=mid-1;
                //mid=(left+right)/2;
            }else if (arr[mid]<toFind) {
                left=mid+1;
                //mid=(left+right)/2;
            }else {
                return mid;
            }
        }
        return -1;
    }

    //查找数组中的指定元素
    //顺序查找（遍历）
    public static int find(int[]arr, int num){

        for (int i = 0; i < arr.length; i++) {
            if(num==arr[i]){
                return i;
            }
        }
        return -1;//用来表示没有找到
    }
    public static double avg(int []arr){
        int sum=0;
        for (int x:arr) {
            sum+=x;

        }

        return (double)sum/(double)arr.length;
    }


    public static void func(){
        //因为newArr和arr引用的是同一个数组
        //所以修改一个空间中的内容后，对另一个也会造成影响
        //
        int[] arr={1,2,3,4,5,6};
        int[] newArr=arr;
        newArr[0]=10;
        System.out.println("newArr:"+Arrays.toString(arr));

        //使用Arrays中的copyOf方法完成数组的拷贝
        //copyOf方法在进行拷贝的时候，创建了一个新的数组
        //arr和newArr引用的不是同一个数组
        //
        arr[0]=1;
        newArr=Arrays.copyOf(arr,arr.length);
        System.out.println("newArr:"+Arrays.toString(newArr));

        //因为aee修改其引用数组中的内容的时候，对newArr没有应i想
        arr[0]=10;
        System.out.println("arr:"+Arrays.toString(arr));
        System.out.println("newArr:"+Arrays.toString(newArr));

        //拷贝某一个范围
        int [] newArr2=Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr2:"+Arrays.toString(newArr2));
        //基本类型怎样去拷贝都不会有问题
        //但是引用类型就会有深拷贝和浅拷贝之分

    }
}